home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / samr.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2006-06-30  |  31KB  |  897 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import array
  5. from time import strftime, gmtime
  6. from struct import *
  7. from impacket import ImpactPacket
  8. import dcerpc
  9. import ndrutils
  10. MSRPC_UUID_SAMR = 'xW4\x124\x12\xcd\xab\xef\x00\x01#Eg\x89\xac\x01\x00\x00\x00'
  11. OP_NUM_CREATE_USER_IN_DOMAIN = 12
  12. OP_NUM_ENUM_USERS_IN_DOMAIN = 13
  13. OP_NUM_CREATE_ALIAS_IN_DOMAIN = 14
  14.  
  15. def display_time(filetime_high, filetime_low, minutes_utc = 0):
  16.     d = filetime_high * 4.0 * 1.0 * (1 << 30)
  17.     d += filetime_low
  18.     d *= 9.9999999999999995e-08
  19.     d -= 369.0 * 365.25 * 24 * 60 * 60 - 3.0 * 24 * 60 * 60 + 6.0 * 60 * 60
  20.     if minutes_utc == 0:
  21.         r = (strftime('%a, %d %b %Y %H:%M:%S', gmtime(d)), minutes_utc / 60)[0]
  22.     else:
  23.         r = '%s GMT %d ' % (strftime('%a, %d %b %Y %H:%M:%S', gmtime(d)), minutes_utc / 60)
  24.     return r
  25.  
  26.  
  27. class MSRPCUserInfo:
  28.     ITEMS = {
  29.         'Account Name': 0,
  30.         'Full Name': 1,
  31.         'Home': 2,
  32.         'Home Drive': 3,
  33.         'Script': 4,
  34.         'Profile': 5,
  35.         'Description': 6,
  36.         'Workstations': 7,
  37.         'Comment': 8,
  38.         'Parameters': 9,
  39.         'Logon hours': 10 }
  40.     
  41.     def __init__(self, data = None):
  42.         self._logon_time_low = 0
  43.         self._logon_time_high = 0
  44.         self._logoff_time_low = 0
  45.         self._logoff_time_high = 0
  46.         self._kickoff_time_low = 0
  47.         self._kickoff_time_high = 0
  48.         self._pwd_last_set_low = 0
  49.         self._pwd_last_set_high = 0
  50.         self._pwd_can_change_low = 0
  51.         self._pwd_can_change_high = 0
  52.         self._pwd_must_change_low = 0
  53.         self._pwd_must_change_high = 0
  54.         self._items = []
  55.         self._rid = 0
  56.         self._group = 0
  57.         self._acct_ctrl = 0
  58.         self._bad_pwd_count = 0
  59.         self._logon_count = 0
  60.         self._country = 0
  61.         self._codepage = 0
  62.         self._nt_pwd_set = 0
  63.         self._lm_pwd_set = 0
  64.         if data:
  65.             self.set_header(data)
  66.         
  67.  
  68.     
  69.     def set_header(self, data):
  70.         index = 8
  71.         (self._logon_time_low, self._logon_time_high, self._logoff_time_low, self._logoff_time_high, self._kickoff_time_low, self._kickoff_time_high, self._pwd_last_set_low, self._pwd_last_set_high, self._pwd_can_change_low, self._pwd_can_change_high, self._pwd_must_change_low, self._pwd_must_change_high) = unpack('<LLLLLLLLLLLL', data[index:index + 48])
  72.         index += 48
  73.         for i in range(0, len(MSRPCUserInfo.ITEMS) - 1):
  74.             (length, size, id) = unpack('<HHL', data[index:index + 8])
  75.             self._items.append(dcerpc.MSRPCArray(length, size, id))
  76.             index += 8
  77.         
  78.         index += 24
  79.         item_count = unpack('<L', data[index:index + 4])[0]
  80.         index += 4 + (item_count + 1) * 4
  81.         (self._rid, self._group, self._acct_ctr, _) = unpack('<LLLL', data[index:index + 16])
  82.         index += 16
  83.         (logon_divisions, _, id) = unpack('<HHL', data[index:index + 8])
  84.         self._items.append(dcerpc.MSRPCArray(logon_divisions, _, id))
  85.         index += 8
  86.         (self._bad_pwd_count, self._logon_count, self._country, self._codepage) = unpack('<HHHH', data[index:index + 8])
  87.         index += 8
  88.         (self._nt_pwd_set, self._lm_pwd_set, _, _) = unpack('<BBBB', data[index:index + 4])
  89.         index += 4
  90.         for item in self._items[:-1]:
  91.             if 0 == item.get_size():
  92.                 continue
  93.             
  94.             (max_len, offset, curlen) = unpack('<LLL', data[index:index + 12])
  95.             index += 12
  96.             item.set_name(unicode(data[index:index + 2 * curlen], 'utf-16le'))
  97.             item.set_max_len(max_len)
  98.             item.set_offset(offset)
  99.             item.set_length2(curlen)
  100.             index += 2 * curlen
  101.             if curlen & 1:
  102.                 index += 2
  103.                 continue
  104.         
  105.         item = self._items[10]
  106.         (max_len, offset, curlen) = unpack('<LLL', data[index:index + 12])
  107.         index += 12
  108.         item.set_name('Unlimited')
  109.         for b in data[index:index + curlen]:
  110.             if 255 != ord(b):
  111.                 item.set_name('Unknown')
  112.                 continue
  113.         
  114.  
  115.     
  116.     def get_num_items(self):
  117.         return len(self._items)
  118.  
  119.     
  120.     def get_items(self):
  121.         return self._items
  122.  
  123.     
  124.     def get_logon_time(self):
  125.         return display_time(self._logon_time_high, self._logon_time_low)
  126.  
  127.     
  128.     def get_logoff_time(self):
  129.         return display_time(self._logoff_time_high, self._logoff_time_low)
  130.  
  131.     
  132.     def get_kickoff_time(self):
  133.         return display_time(self._kickoff_time_high, self._kickoff_time_low)
  134.  
  135.     
  136.     def get_pwd_last_set(self):
  137.         return display_time(self._pwd_last_set_high, self._pwd_last_set_low)
  138.  
  139.     
  140.     def get_pwd_can_change(self):
  141.         return display_time(self._pwd_can_change_high, self._pwd_can_change_low)
  142.  
  143.     
  144.     def get_group_id(self):
  145.         return self._group
  146.  
  147.     
  148.     def get_bad_pwd_count(self):
  149.         return self._bad_pwd_count
  150.  
  151.     
  152.     def get_logon_count(self):
  153.         return self._logon_count
  154.  
  155.     
  156.     def get_pwd_must_change(self):
  157.         if self._pwd_must_change_low == 0xFFFFFFFFL:
  158.             return 'Infinity'
  159.         else:
  160.             return display_time(self._pwd_must_change_high, self._pwd_must_change_low)
  161.  
  162.     
  163.     def is_enabled(self):
  164.         return not (self._acct_ctr & 1)
  165.  
  166.     
  167.     def print_friendly(self):
  168.         print 'Last Logon: ' + display_time(self._logon_time_high, self._logon_time_low)
  169.         print 'Last Logoff: ' + display_time(self._logoff_time_high, self._logoff_time_low)
  170.         print 'Kickoff Time: ' + display_time(self._kickoff_time_high, self._kickoff_time_low)
  171.         print 'PWD Last Set: ' + display_time(self._pwd_last_set_high, self._pwd_last_set_low)
  172.         print 'PWD Can Change: ' + display_time(self._pwd_can_change_high, self._pwd_can_change_low)
  173.         print 'Group id: %d' % self._group
  174.         print 'Bad pwd count: %d' % self._bad_pwd_count
  175.         print 'Logon count: %d' % self._logon_count
  176.         if self._pwd_must_change_low == 0xFFFFFFFFL:
  177.             print 'PWD Must Change: Infinity'
  178.         else:
  179.             print 'PWD Must Change: ' + display_time(self._pwd_must_change_high, self._pwd_must_change_low)
  180.         for i in MSRPCUserInfo.ITEMS.keys():
  181.             print i + ': ' + self._items[MSRPCUserInfo.ITEMS[i]].get_name()
  182.         
  183.         print 
  184.  
  185.  
  186.  
  187. class SAMRConnectHeader(ImpactPacket.Header):
  188.     OP_NUM = 57
  189.     __SIZE = 4
  190.     
  191.     def __init__(self, aBuffer = None):
  192.         ImpactPacket.Header.__init__(self, SAMRConnectHeader._SAMRConnectHeader__SIZE)
  193.         self._SAMRConnectHeader__sptr = ndrutils.NDRPointer()
  194.         self.set_server('')
  195.         self.set_access_mask(33554432)
  196.         if aBuffer:
  197.             self.load_header(aBuffer)
  198.         
  199.  
  200.     
  201.     def get_server(self):
  202.         return ndrutils.NDRPointer(self.get_bytes()[:-4].tostring(), ndrutils.NDRString)
  203.  
  204.     
  205.     def set_server(self, name):
  206.         ss = ndrutils.NDRString()
  207.         ss.set_string(name)
  208.         self._SAMRConnectHeader__sptr.set_pointer(ss)
  209.         data = self._SAMRConnectHeader__sptr.rawData()
  210.         self.get_bytes()[:-4] = array.array('B', data)
  211.  
  212.     
  213.     def get_access_mask(self):
  214.         return self.get_long(-4, '<')
  215.  
  216.     
  217.     def set_access_mask(self, mask):
  218.         self.set_long(-4, mask, '<')
  219.  
  220.     
  221.     def get_header_size(self):
  222.         var_size = len(self.get_bytes()) - SAMRConnectHeader._SAMRConnectHeader__SIZE
  223.         if not var_size > 0:
  224.             raise AssertionError
  225.         return SAMRConnectHeader._SAMRConnectHeader__SIZE + var_size
  226.  
  227.  
  228.  
  229. class SAMRRespConnectHeader(ImpactPacket.Header):
  230.     __SIZE = 24
  231.     
  232.     def __init__(self, aBuffer = None):
  233.         ImpactPacket.Header.__init__(self, SAMRRespConnectHeader._SAMRRespConnectHeader__SIZE)
  234.         if aBuffer:
  235.             self.load_header(aBuffer)
  236.         
  237.  
  238.     
  239.     def get_context_handle(self):
  240.         return self.get_bytes().tostring()[:20]
  241.  
  242.     
  243.     def set_context_handle(self, handle):
  244.         if not 20 == len(handle):
  245.             raise AssertionError
  246.         self.get_bytes()[:20] = array.array('B', handle)
  247.  
  248.     
  249.     def get_return_code(self):
  250.         return self.get_long(20, '<')
  251.  
  252.     
  253.     def set_return_code(self, code):
  254.         self.set_long(20, code, '<')
  255.  
  256.     
  257.     def get_header_size(self):
  258.         return SAMRRespConnectHeader._SAMRRespConnectHeader__SIZE
  259.  
  260.  
  261.  
  262. class SAMREnumDomainsHeader(ImpactPacket.Header):
  263.     OP_NUM = 6
  264.     __SIZE = 28
  265.     
  266.     def __init__(self, aBuffer = None):
  267.         ImpactPacket.Header.__init__(self, SAMREnumDomainsHeader._SAMREnumDomainsHeader__SIZE)
  268.         self.set_pref_max_size(8192)
  269.         if aBuffer:
  270.             self.load_header(aBuffer)
  271.         
  272.  
  273.     
  274.     def get_context_handle(self):
  275.         return self.get_bytes().tolist()[:20]
  276.  
  277.     
  278.     def set_context_handle(self, handle):
  279.         if not 20 == len(handle):
  280.             raise AssertionError
  281.         self.get_bytes()[:20] = array.array('B', handle)
  282.  
  283.     
  284.     def get_resume_handle(self):
  285.         return self.get_long(20, '<')
  286.  
  287.     
  288.     def set_resume_handle(self, handle):
  289.         self.set_long(20, handle, '<')
  290.  
  291.     
  292.     def get_pref_max_size(self):
  293.         return self.get_long(24, '<')
  294.  
  295.     
  296.     def set_pref_max_size(self, size):
  297.         self.set_long(24, size, '<')
  298.  
  299.     
  300.     def get_header_size(self):
  301.         return SAMREnumDomainsHeader._SAMREnumDomainsHeader__SIZE
  302.  
  303.  
  304.  
  305. class SAMRRespEnumDomainHeader(ImpactPacket.Header):
  306.     __SIZE = 12
  307.     
  308.     def __init__(self, aBuffer = None):
  309.         ImpactPacket.Header.__init__(self, SAMRRespEnumDomainHeader._SAMRRespEnumDomainHeader__SIZE)
  310.         if aBuffer:
  311.             self.load_header(aBuffer)
  312.         
  313.  
  314.     
  315.     def get_resume_handle(self):
  316.         return self.get_long(0, '<')
  317.  
  318.     
  319.     def set_resume_handle(self, handle):
  320.         self.set_long(0, handle, '<')
  321.  
  322.     
  323.     def get_domains(self):
  324.         return dcerpc.MSRPCNameArray(self.get_bytes()[4:-8].tostring())
  325.  
  326.     
  327.     def set_domains(self, domains):
  328.         if not isinstance(domains, dcerpc.MSRPCNameArray):
  329.             raise AssertionError
  330.         self.get_bytes()[4:-8] = array.array('B', domains.rawData())
  331.  
  332.     
  333.     def get_entries_num(self):
  334.         return self.get_long(-8, '<')
  335.  
  336.     
  337.     def set_entries_num(self, num):
  338.         self.set_long(-8, num, '<')
  339.  
  340.     
  341.     def get_return_code(self):
  342.         return self.get_long(-4, '<')
  343.  
  344.     
  345.     def set_return_code(self, code):
  346.         self.set_long(-4, code, '<')
  347.  
  348.     
  349.     def get_header_size(self):
  350.         var_size = len(self.get_bytes()) - SAMRRespEnumDomainHeader._SAMRRespEnumDomainHeader__SIZE
  351.         if not var_size > 0:
  352.             raise AssertionError
  353.         return SAMRRespEnumDomainHeader._SAMRRespEnumDomainHeader__SIZE + var_size
  354.  
  355.  
  356.  
  357. class SAMRLookupDomainHeader(ImpactPacket.Header):
  358.     OP_NUM = 5
  359.     __SIZE = 20
  360.     
  361.     def __init__(self, aBuffer = None):
  362.         ImpactPacket.Header.__init__(self, SAMRLookupDomainHeader._SAMRLookupDomainHeader__SIZE)
  363.         if aBuffer:
  364.             self.load_header(aBuffer)
  365.         
  366.  
  367.     
  368.     def get_context_handle(self):
  369.         return self.get_bytes().tolist()[:20]
  370.  
  371.     
  372.     def set_context_handle(self, handle):
  373.         if not 20 == len(handle):
  374.             raise AssertionError
  375.         self.get_bytes()[:20] = array.array('B', handle)
  376.  
  377.     
  378.     def get_domain(self):
  379.         return dcerpc.MSRPCArray(self.get_bytes().tolist()[20:])
  380.  
  381.     
  382.     def set_domain(self, domain):
  383.         if not isinstance(domain, dcerpc.MSRPCArray):
  384.             raise AssertionError
  385.         self.get_bytes()[20:] = array.array('B', domain.rawData())
  386.  
  387.     
  388.     def get_header_size(self):
  389.         var_size = len(self.get_bytes()) - SAMRLookupDomainHeader._SAMRLookupDomainHeader__SIZE
  390.         if not var_size > 0:
  391.             raise AssertionError
  392.         return SAMRLookupDomainHeader._SAMRLookupDomainHeader__SIZE + var_size
  393.  
  394.  
  395.  
  396. class SAMRRespLookupDomainHeader(ImpactPacket.Header):
  397.     __SIZE = 36
  398.     
  399.     def __init__(self, aBuffer = None):
  400.         ImpactPacket.Header.__init__(self, SAMRRespLookupDomainHeader._SAMRRespLookupDomainHeader__SIZE)
  401.         if aBuffer:
  402.             self.load_header(aBuffer)
  403.         
  404.  
  405.     
  406.     def get_domain_sid(self):
  407.         return self.get_bytes().tolist()[4:4 + 28]
  408.  
  409.     
  410.     def set_domain_sid(self, sid):
  411.         if not 28 == len(sid):
  412.             raise AssertionError
  413.         self.get_bytes()[4:4 + 28] = array.array('B', sid)
  414.  
  415.     
  416.     def get_return_code(self):
  417.         return self.get_long(32, '<')
  418.  
  419.     
  420.     def set_return_code(self, code):
  421.         self.set_long(32, code, '<')
  422.  
  423.     
  424.     def get_header_size(self):
  425.         return SAMRRespLookupDomainHeader._SAMRRespLookupDomainHeader__SIZE
  426.  
  427.  
  428.  
  429. class SAMROpenDomainHeader(ImpactPacket.Header):
  430.     OP_NUM = 7
  431.     __SIZE = 52
  432.     
  433.     def __init__(self, aBuffer = None):
  434.         ImpactPacket.Header.__init__(self, SAMROpenDomainHeader._SAMROpenDomainHeader__SIZE)
  435.         self.set_access_mask(772)
  436.         if aBuffer:
  437.             self.load_header(aBuffer)
  438.         
  439.  
  440.     
  441.     def get_context_handle(self):
  442.         return self.get_bytes().tolist()[:20]
  443.  
  444.     
  445.     def set_context_handle(self, handle):
  446.         if not 20 == len(handle):
  447.             raise AssertionError
  448.         self.get_bytes()[:20] = array.array('B', handle)
  449.  
  450.     
  451.     def get_access_mask(self):
  452.         return self.get_long(20, '<')
  453.  
  454.     
  455.     def set_access_mask(self, mask):
  456.         self.set_long(20, mask, '<')
  457.  
  458.     
  459.     def get_domain_sid(self):
  460.         return self.get_bytes().tolist()[24:24 + 28]
  461.  
  462.     
  463.     def set_domain_sid(self, sid):
  464.         if not 28 == len(sid):
  465.             raise AssertionError
  466.         self.get_bytes()[24:24 + 28] = array.array('B', sid)
  467.  
  468.     
  469.     def get_header_size(self):
  470.         return SAMROpenDomainHeader._SAMROpenDomainHeader__SIZE
  471.  
  472.  
  473.  
  474. class SAMRRespOpenDomainHeader(ImpactPacket.Header):
  475.     __SIZE = 24
  476.     
  477.     def __init__(self, aBuffer = None):
  478.         ImpactPacket.Header.__init__(self, SAMRRespOpenDomainHeader._SAMRRespOpenDomainHeader__SIZE)
  479.         if aBuffer:
  480.             self.load_header(aBuffer)
  481.         
  482.  
  483.     
  484.     def get_context_handle(self):
  485.         return self.get_bytes().tolist()[:20]
  486.  
  487.     
  488.     def set_context_handle(self, handle):
  489.         if not 20 == len(handle):
  490.             raise AssertionError
  491.         self.get_bytes()[:20] = array.array('B', handle)
  492.  
  493.     
  494.     def get_return_code(self):
  495.         return self.get_long(20, '<')
  496.  
  497.     
  498.     def set_return_code(self, code):
  499.         self.set_long(20, code, '<')
  500.  
  501.     
  502.     def get_header_size(self):
  503.         return SAMRRespOpenDomainHeader._SAMRRespOpenDomainHeader__SIZE
  504.  
  505.  
  506.  
  507. class SAMREnumDomainUsersHeader(ImpactPacket.Header):
  508.     OP_NUM = OP_NUM_ENUM_USERS_IN_DOMAIN
  509.     __SIZE = 32
  510.     
  511.     def __init__(self, aBuffer = None):
  512.         ImpactPacket.Header.__init__(self, SAMREnumDomainUsersHeader._SAMREnumDomainUsersHeader__SIZE)
  513.         self.set_pref_max_size(3275)
  514.         if aBuffer:
  515.             self.load_header(aBuffer)
  516.         
  517.  
  518.     
  519.     def get_context_handle(self):
  520.         return self.get_bytes().tolist()[:20]
  521.  
  522.     
  523.     def set_context_handle(self, handle):
  524.         if not 20 == len(handle):
  525.             raise AssertionError
  526.         self.get_bytes()[:20] = array.array('B', handle)
  527.  
  528.     
  529.     def get_resume_handle(self):
  530.         return self.get_long(20, '<')
  531.  
  532.     
  533.     def set_resume_handle(self, handle):
  534.         self.set_long(20, handle, '<')
  535.  
  536.     
  537.     def get_account_control(self):
  538.         return self.get_long(24, '<')
  539.  
  540.     
  541.     def set_account_control(self, mask):
  542.         self.set_long(24, mask, '<')
  543.  
  544.     
  545.     def get_pref_max_size(self):
  546.         return self.get_long(28, '<')
  547.  
  548.     
  549.     def set_pref_max_size(self, size):
  550.         self.set_long(28, size, '<')
  551.  
  552.     
  553.     def get_header_size(self):
  554.         return SAMREnumDomainUsersHeader._SAMREnumDomainUsersHeader__SIZE
  555.  
  556.  
  557.  
  558. class SAMRRespEnumDomainUsersHeader(ImpactPacket.Header):
  559.     __SIZE = 16
  560.     
  561.     def __init__(self, aBuffer = None):
  562.         ImpactPacket.Header.__init__(self, SAMRRespEnumDomainUsersHeader._SAMRRespEnumDomainUsersHeader__SIZE)
  563.         if aBuffer:
  564.             self.load_header(aBuffer)
  565.         
  566.  
  567.     
  568.     def get_resume_handle(self):
  569.         return self.get_long(0, '<')
  570.  
  571.     
  572.     def set_resume_handle(self, handle):
  573.         self.set_long(0, handle, '<')
  574.  
  575.     
  576.     def get_users(self):
  577.         return dcerpc.MSRPCNameArray(self.get_bytes()[4:-8].tostring())
  578.  
  579.     
  580.     def set_users(self, users):
  581.         if not isinstance(users, dcerpc.MSRPCNameArray):
  582.             raise AssertionError
  583.         self.get_bytes()[4:-8] = array.array('B', users.rawData())
  584.  
  585.     
  586.     def get_entries_num(self):
  587.         return self.get_long(-8, '<')
  588.  
  589.     
  590.     def set_entries_num(self, num):
  591.         self.set_long(-8, num, '<')
  592.  
  593.     
  594.     def get_return_code(self):
  595.         return self.get_long(-4, '<')
  596.  
  597.     
  598.     def set_return_code(self, code):
  599.         self.set_long(-4, code, '<')
  600.  
  601.     
  602.     def get_header_size(self):
  603.         var_size = len(self.get_bytes()) - SAMRRespEnumDomainUsersHeader._SAMRRespEnumDomainUsersHeader__SIZE
  604.         if not var_size > 0:
  605.             raise AssertionError
  606.         return SAMRRespEnumDomainUsersHeader._SAMRRespEnumDomainUsersHeader__SIZE + var_size
  607.  
  608.  
  609.  
  610. class SAMROpenUserHeader(ImpactPacket.Header):
  611.     OP_NUM = 34
  612.     __SIZE = 28
  613.     
  614.     def __init__(self, aBuffer = None):
  615.         ImpactPacket.Header.__init__(self, SAMROpenUserHeader._SAMROpenUserHeader__SIZE)
  616.         self.set_access_mask(131355)
  617.         if aBuffer:
  618.             self.load_header(aBuffer)
  619.         
  620.  
  621.     
  622.     def get_context_handle(self):
  623.         return self.get_bytes().tolist()[:20]
  624.  
  625.     
  626.     def set_context_handle(self, handle):
  627.         if not 20 == len(handle):
  628.             raise AssertionError
  629.         self.get_bytes()[:20] = array.array('B', handle)
  630.  
  631.     
  632.     def get_access_mask(self):
  633.         return self.get_long(20, '<')
  634.  
  635.     
  636.     def set_access_mask(self, mask):
  637.         self.set_long(20, mask, '<')
  638.  
  639.     
  640.     def get_rid(self):
  641.         return self.get_long(24, '<')
  642.  
  643.     
  644.     def set_rid(self, id):
  645.         self.set_long(24, id, '<')
  646.  
  647.     
  648.     def get_header_size(self):
  649.         return SAMROpenUserHeader._SAMROpenUserHeader__SIZE
  650.  
  651.  
  652.  
  653. class SAMRRespOpenUserHeader(ImpactPacket.Header):
  654.     __SIZE = 24
  655.     
  656.     def __init__(self, aBuffer = None):
  657.         ImpactPacket.Header.__init__(self, SAMRRespOpenUserHeader._SAMRRespOpenUserHeader__SIZE)
  658.         if aBuffer:
  659.             self.load_header(aBuffer)
  660.         
  661.  
  662.     
  663.     def get_context_handle(self):
  664.         return self.get_bytes().tolist()[:20]
  665.  
  666.     
  667.     def set_context_handle(self, handle):
  668.         if not 20 == len(handle):
  669.             raise AssertionError
  670.         self.get_bytes()[:20] = array.array('B', handle)
  671.  
  672.     
  673.     def get_return_code(self):
  674.         return self.get_long(20, '<')
  675.  
  676.     
  677.     def set_return_code(self, code):
  678.         self.set_long(20, code, '<')
  679.  
  680.     
  681.     def get_header_size(self):
  682.         return SAMRRespOpenUserHeader._SAMRRespOpenUserHeader__SIZE
  683.  
  684.  
  685.  
  686. class SAMRQueryUserInfoHeader(ImpactPacket.Header):
  687.     OP_NUM = 36
  688.     __SIZE = 22
  689.     
  690.     def __init__(self, aBuffer = None):
  691.         ImpactPacket.Header.__init__(self, SAMRQueryUserInfoHeader._SAMRQueryUserInfoHeader__SIZE)
  692.         self.set_level(21)
  693.         if aBuffer:
  694.             self.load_header(aBuffer)
  695.         
  696.  
  697.     
  698.     def get_context_handle(self):
  699.         return self.get_bytes().tolist()[:20]
  700.  
  701.     
  702.     def set_context_handle(self, handle):
  703.         if not 20 == len(handle):
  704.             raise AssertionError
  705.         self.get_bytes()[:20] = array.array('B', handle)
  706.  
  707.     
  708.     def get_level(self):
  709.         return self.get_word(20, '<')
  710.  
  711.     
  712.     def set_level(self, level):
  713.         self.set_word(20, level, '<')
  714.  
  715.     
  716.     def get_header_size(self):
  717.         return SAMRQueryUserInfoHeader._SAMRQueryUserInfoHeader__SIZE
  718.  
  719.  
  720.  
  721. class SAMRRespQueryUserInfoHeader(ImpactPacket.Header):
  722.     __SIZE = 4
  723.     
  724.     def __init__(self, aBuffer = None):
  725.         ImpactPacket.Header.__init__(self, SAMRRespQueryUserInfoHeader._SAMRRespQueryUserInfoHeader__SIZE)
  726.         if aBuffer:
  727.             self.load_header(aBuffer)
  728.         
  729.  
  730.     
  731.     def get_user_info(self):
  732.         return MSRPCUserInfo(self.get_bytes()[:-4].tostring())
  733.  
  734.     
  735.     def set_user_info(self, info):
  736.         if not isinstance(info, MSRPCUserInfo):
  737.             raise AssertionError
  738.         self.get_bytes()[:-4] = array.array('B', info.rawData())
  739.  
  740.     
  741.     def get_return_code(self):
  742.         return self.get_long(-4, '<')
  743.  
  744.     
  745.     def set_return_code(self, code):
  746.         self.set_long(-4, code, '<')
  747.  
  748.     
  749.     def get_header_size(self):
  750.         var_size = len(self.get_bytes()) - SAMRRespQueryUserInfoHeader._SAMRRespQueryUserInfoHeader__SIZE
  751.         if not var_size > 0:
  752.             raise AssertionError
  753.         return SAMRRespQueryUserInfoHeader._SAMRRespQueryUserInfoHeader__SIZE + var_size
  754.  
  755.  
  756.  
  757. class SAMRCloseRequestHeader(ImpactPacket.Header):
  758.     OP_NUM = 1
  759.     __SIZE = 20
  760.     
  761.     def __init__(self, aBuffer = None):
  762.         ImpactPacket.Header.__init__(self, SAMRCloseRequestHeader._SAMRCloseRequestHeader__SIZE)
  763.         if aBuffer:
  764.             self.load_header(aBuffer)
  765.         
  766.  
  767.     
  768.     def get_context_handle(self):
  769.         return self.get_bytes().tolist()[:20]
  770.  
  771.     
  772.     def set_context_handle(self, handle):
  773.         if not 20 == len(handle):
  774.             raise AssertionError
  775.         self.get_bytes()[:20] = array.array('B', handle)
  776.  
  777.     
  778.     def get_header_size(self):
  779.         return SAMRCloseRequestHeader._SAMRCloseRequestHeader__SIZE
  780.  
  781.  
  782.  
  783. class SAMRRespCloseRequestHeader(ImpactPacket.Header):
  784.     __SIZE = 24
  785.     
  786.     def __init__(self, aBuffer = None):
  787.         ImpactPacket.Header.__init__(self, SAMRRespCloseRequestHeader._SAMRRespCloseRequestHeader__SIZE)
  788.         if aBuffer:
  789.             self.load_header(aBuffer)
  790.         
  791.  
  792.     
  793.     def get_context_handle(self):
  794.         return self.get_bytes().tolist()[:20]
  795.  
  796.     
  797.     def set_context_handle(self, handle):
  798.         if not 20 == len(handle):
  799.             raise AssertionError
  800.         self.get_bytes()[:20] = array.array('B', handle)
  801.  
  802.     
  803.     def get_return_code(self):
  804.         return self.get_long(20, '<')
  805.  
  806.     
  807.     def set_return_code(self, code):
  808.         self.set_long(20, code, '<')
  809.  
  810.     
  811.     def get_header_size(self):
  812.         return SAMRRespCloseRequestHeader._SAMRRespCloseRequestHeader__SIZE
  813.  
  814.  
  815.  
  816. class DCERPCSamr:
  817.     
  818.     def __init__(self, dcerpc):
  819.         self._dcerpc = dcerpc
  820.  
  821.     
  822.     def connect(self):
  823.         samrcon = SAMRConnectHeader()
  824.         samrcon.set_server('*SMBSERVER')
  825.         self._dcerpc.send(samrcon)
  826.         data = self._dcerpc.recv()
  827.         retVal = SAMRRespConnectHeader(data)
  828.         return retVal
  829.  
  830.     
  831.     def enumdomains(self, context_handle):
  832.         enumdom = SAMREnumDomainsHeader()
  833.         enumdom.set_context_handle(context_handle)
  834.         self._dcerpc.send(enumdom)
  835.         data = self._dcerpc.recv()
  836.         retVal = SAMRRespEnumDomainHeader(data)
  837.         return retVal
  838.  
  839.     
  840.     def lookupdomain(self, context_handle, domain):
  841.         lookupdom = SAMRLookupDomainHeader()
  842.         lookupdom.set_context_handle(context_handle)
  843.         lookupdom.set_domain(domain)
  844.         self._dcerpc.send(lookupdom)
  845.         data = self._dcerpc.recv()
  846.         retVal = SAMRRespLookupDomainHeader(data)
  847.         return retVal
  848.  
  849.     
  850.     def opendomain(self, context_handle, domain_sid):
  851.         opendom = SAMROpenDomainHeader()
  852.         opendom.set_context_handle(context_handle)
  853.         opendom.set_domain_sid(domain_sid)
  854.         self._dcerpc.send(opendom)
  855.         data = self._dcerpc.recv()
  856.         retVal = SAMRRespOpenDomainHeader(data)
  857.         return retVal
  858.  
  859.     
  860.     def enumusers(self, context_handle):
  861.         enumusers = SAMREnumDomainUsersHeader()
  862.         enumusers.set_context_handle(context_handle)
  863.         self._dcerpc.send(enumusers)
  864.         data = self._dcerpc.recv()
  865.         retVal = SAMRRespEnumDomainUsersHeader(data)
  866.         return retVal
  867.  
  868.     
  869.     def openuser(self, context_handle, rid):
  870.         openuser = SAMROpenUserHeader()
  871.         openuser.set_context_handle(context_handle)
  872.         openuser.set_rid(rid)
  873.         self._dcerpc.send(openuser)
  874.         data = self._dcerpc.recv()
  875.         retVal = SAMRRespOpenUserHeader(data)
  876.         return retVal
  877.  
  878.     
  879.     def queryuserinfo(self, context_handle):
  880.         userinfo = SAMRQueryUserInfoHeader()
  881.         userinfo.set_context_handle(context_handle)
  882.         self._dcerpc.send(userinfo)
  883.         data = self._dcerpc.recv()
  884.         retVal = SAMRRespQueryUserInfoHeader(data)
  885.         return retVal
  886.  
  887.     
  888.     def closerequest(self, context_handle):
  889.         closereq = SAMRCloseRequestHeader()
  890.         closereq.set_context_handle(context_handle)
  891.         self._dcerpc.send(closereq)
  892.         data = self._dcerpc.recv()
  893.         retVal = SAMRRespCloseRequestHeader(data)
  894.         return retVal
  895.  
  896.  
  897.